Celestin Apprentice 4/Apprentice-Release4.iso/Languages/MPW Oberon 2.1168/OInterfaces/OSA.mod

Text File | 1995-08-10 | 54.3 KB | 1,418 lines | [TEXT/MPS ]

(*
     File:        OSA.mod

     Contains:    AppleScript Client Interfaces.

     Version:    Technology:    AppleScript 1.1
                 Package:    Universal Interfaces 2.0 in “MPW Latest” on ETO #17

     Copyright:    © 1984-1995 by Apple Computer, Inc.
                 All rights reserved.

     Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
                 stack.  Include the file and version information (from above)
                 in the problem description and send to:
                     Internet:    apple.bugs.applelink.apple.com
                     AppleLink:    APPLE.BUGS

*)

(*$TAGS-*)
(*$CALLING PASCAL*)
MODULE OSA;

IMPORT SYSTEM, Types, Errors, AppleEvents, Components;

(* $PUSH*)
(* $ALIGN MAC68K*)
(* $LibExport+*)

CONST
    kOSAComponentType*            = LONG("osa ");

(* 0x73637074 *)
    kOSAGenericScriptingComponentSubtype* = LONG("scpt");

(*    Type of script document files.    *)
(* 0x6f736173 *)
    kOSAFileType*                = LONG("osas");

(*
        Suite and event code of the RecordedText event.
        (See OSAStartRecording, below.)
    *)
(* 0x61736372 *)
    kOSASuite*                    = LONG("ascr");

(* 0x72656364 *)
    kOSARecordedText*            = LONG("recd");

(* Selector returns boolean *)
(* 0x6d6f6469 *)
    kOSAScriptIsModified*        = LONG("modi");

(* Selector returns boolean *)
(* 0x63736372 *)
    kOSAScriptIsTypeCompiledScript* = LONG("cscr");

(* Selector returns boolean *)
(* 0x76616c75 *)
    kOSAScriptIsTypeScriptValue*    = LONG("valu");

(* Selector returns boolean *)
(* 0x636e7478 *)
    kOSAScriptIsTypeScriptContext* = LONG("cntx");

(* Selector returns a AppleEvents.DescType which may be passed to OSACoerceToDesc *)
(* 0x62657374 *)
    kOSAScriptBestType*            = LONG("best");

(*
        This selector is used to determine whether a script has source
        associated with it that when given to OSAGetSource, the call will not
        fail.  The selector returns a boolean.
    *)
(* 0x67737263 *)
    kOSACanGetSource*            = LONG("gsrc");

    typeOSADialectInfo*            = LONG("difo");                        (*  0x6469666f   *)
    keyOSADialectName*            = LONG("dnam");                        (*  0x646e616d   *)
    keyOSADialectCode*            = LONG("dcod");                        (*  0x64636f64   *)
    keyOSADialectLangCode*        = LONG("dlcd");                        (*  0x646c6364   *)
    keyOSADialectScriptCode*        = LONG("dscd");


TYPE
    OSAError* = Components.ComponentResult;

(* Under the Open Scripting Architecture all error results are longs *)
    OSAID* = LONGINT;

(*
        OSAIDs allow transparent manipulation of scripts associated with
         various scripting systems.
    *)

CONST
    kOSANullScript*                = 0;

(* No -script constant. *)
    kOSANullMode*                = 0;                            (* sounds better *)
    kOSAModeNull*                = 0;                            (* tastes consistent *)

(*
        Some routines take flags that control their execution.  This constant
        declares default mode settings are used.
    *)
TYPE
    OSACreateAppleEventProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (theAEEventClass: AppleEvents.AEEventClass; theAEEventID: AppleEvents.AEEventID; (*CONST*)VAR target: AppleEvents.AEAddressDesc; returnID: INTEGER; transactionID: LONGINT; VAR result: AppleEvents.AppleEvent; refCon: LONGINT): Types.OSErr;
    OSACreateAppleEventUPP* = Types.UniversalProcPtr;

CONST
    uppOSACreateAppleEventProcInfo* = $000FEFE0; (* PROCEDURE (4 byte param, 4 byte param, 4 byte param, 2 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; *)

PROCEDURE NewOSACreateAppleEventProc*(userRoutine: OSACreateAppleEventProcPtr): OSACreateAppleEventUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE CallOSACreateAppleEventProc*(theAEEventClass: AppleEvents.AEEventClass; theAEEventID: AppleEvents.AEEventID; (*CONST*)VAR target: AppleEvents.AEAddressDesc; returnID: INTEGER; transactionID: LONGINT; VAR result: AppleEvents.AppleEvent; refCon: LONGINT; userRoutine: OSACreateAppleEventUPP): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)
TYPE
    OSASendProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE ((*CONST*)VAR theAppleEvent: AppleEvents.AppleEvent; VAR reply: AppleEvents.AppleEvent; sendMode: AppleEvents.AESendMode; sendPriority: AppleEvents.AESendPriority; timeOutInTicks: LONGINT; idleProc: AppleEvents.AEIdleUPP; filterProc: AppleEvents.AEFilterUPP; refCon: LONGINT): Types.OSErr;
    OSASendUPP* = Types.UniversalProcPtr;

CONST
    uppOSASendProcInfo* = $003FEFE0; (* PROCEDURE (4 byte param, 4 byte param, 4 byte param, 2 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; *)

PROCEDURE NewOSASendProc*(userRoutine: OSASendProcPtr): OSASendUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE CallOSASendProc*((*CONST*)VAR theAppleEvent: AppleEvents.AppleEvent; VAR reply: AppleEvents.AppleEvent; sendMode: AppleEvents.AESendMode; sendPriority: AppleEvents.AESendPriority; timeOutInTicks: LONGINT; idleProc: AppleEvents.AEIdleUPP; filterProc: AppleEvents.AEFilterUPP; refCon: LONGINT; userRoutine: OSASendUPP): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)
(**************************************************************************
    Standard Script Errors
**************************************************************************
    It is recommended that scripting components use the following set of error
    codes to signal failure when applicable.  This enables applications that
    use the OSA API to deal with some class of script errors in a less than
    ad hoc manner.  Scripting components are of course encouraged to return
    component-specific errors when these don't apply.
**************************************************************************)
(*        Dynamic errors*:

    These errors result from data-dependent conditions and are typically
    signaled at runtime.
*)
(*
        Signaled when a value can't be coerced to the desired type. Similar
          to errOSATypeError except results from coercion.
    *)

CONST
    errOSACantCoerce*            = Errors.errAECoercionFail;

(* Signaled when an object is not found in a container *)
    errOSACantAccess*            = Errors.errAENoSuchObject;

(*
        Signaled when an object cannot be set in a container.  Same as
          AERegistry error errAEWriteDenied.
    *)
    errOSACantAssign*            = -10006;

(*
        Signaled by user scripts or applications when no actual error code
          is to be returned.  Simply means "an error has occurred".  Most useful
          in conjunction with an error message from the application.
    *)
    errOSAGeneralError*            = -2700;

(* Signaled when there is an attempt to divide by zero *)
    errOSADivideByZero*            = -2701;

(* Signaled when integer or real value is too large to be represented *)
    errOSANumericOverflow*        = -2702;

(*
        Signaled when application can't be launched or when it is remote and
          program linking is not enabled.
    *)
    errOSACantLaunch*            = -2703;

(* Signaled when an application can't respond to AppleEvents *)
    errOSAAppNotHighLevelEventAware* = -2704;

(* Signaled when an application's terminology resource is not readable *)
    errOSACorruptTerminology*    = -2705;

(* Signaled when the runtime stack overflows *)
    errOSAStackOverflow*            = -2706;

(* Signaled when a runtime internal data structure overflows *)
    errOSAInternalTableOverflow*    = -2707;

(*
        Signaled when an intrinsic limitation is exceeded for the size of
          a value or data structure.
    *)
    errOSADataBlockTooLarge*        = -2708;

    errOSACantGetTerminology*    = -2709;

    errOSACantCreate*            = -2710;

(*        Components.Component-specific dynamic script errors*:

    The range -2720 thru -2739 is reserved for component-specific runtime errors.
    (Note that error codes from different scripting components in this range will
    overlap.)
*)
(*        Static errors*:

    These errors comprise what are commonly thought of as parse and compile-
    time errors.  However, in a dynamic system (e.g. AppleScript) any or all
    of these may also occur at runtime.
*)
(* Signaled when data was not the right type and coercion is not allowed *)
    errOSATypeError*                = Errors.errAEWrongDataType;

(* Signaled when a message was sent to an object that didn't handle it *)
    OSAMessageNotUnderstood*        = Errors.errAEEventNotHandled;

(*
        Signaled when a function to be returned doesn't exist.  (Probably only
          useful in languages with first-class functions that distinguish between
          functions and other values (two name spaces). This is different from
          errOSAMessageNotUnderstood, which may be signaled when the method is
          invoked.
    *)
    OSAUndefinedHandler*            = Errors.errAEHandlerNotFound;

(* Signaled when a container can never have the requested object *)
    OSAIllegalAccess*            = Errors.errAEAccessorNotFound;

(* Signaled when index was out of range. Specialization of errOSACantAccess. *)
    OSAIllegalIndex*                = Errors.errAEIllegalIndex;

(* Signaled when a range is screwy. Specialization of errOSACantAccess. *)
    OSAIllegalRange*                = Errors.errAEImpossibleRange;

(*
        Signaled when an object can never be set in a container.  Same as
          AERegistry error errAENotModifiable.
    *)
    OSAIllegalAssign*            = -10003;

(*
        Signaled when a syntax error occurs. (e.g. "Syntax error" or
         "<this> can't go after <that>").
    *)
    OSASyntaxError*                = -2740;

(*
        Signaled when another form of syntax was expected. (e.g. "expected
          a <type> but found <this>").
    *)
    OSASyntaxTypeError*            = -2741;

(* Signaled when a name or number is too long to be parsed *)
    OSATokenTooLong*                = -2742;

(*
        Signaled when a parameter is missing for a function invocation.  Note
          that in some languages, this error may occur at runtime.
    *)
    OSAMissingParameter*            = Errors.errAEDescNotFound;

(*
        Signaled when function is called with the wrong number of parameters,
          or a parameter pattern cannot be matched.
    *)
    OSAParameterMismatch*        = Errors.errAEWrongNumberArgs;

(*
        Signaled when a formal parameter, local variable, or instance variable
          is specified more than once.
    *)
    OSADuplicateParameter*        = -2750;

(*
        Signaled when a formal parameter, local variable, or instance variable
          is specified more than once.
    *)
    OSADuplicateProperty*        = -2751;

(*
        Signaled when more than one handler is defined with the same name in
          a scope where the language doesn't allow it.
    *)
    OSADuplicateHandler*            = -2752;

(* Signaled when a variable is accessed that has no value *)
    OSAUndefinedVariable*        = -2753;

(*
        Signaled when a variable is declared inconsistently in the same scope,
          such as both local and global.
    *)
    OSAInconsistentDeclarations*    = -2754;

(*
        Signaled when illegal control flow occurs in an application (no catcher
          for throw, non-lexical loop exit, etc.).
    *)
    OSAControlFlowError*            = -2755;

(*        Components.Component-specific static script errors*:

    The range -2760 thru -2779 is reserved for component-specific parsing and
    compile-time errors. (Note that error codes from different scripting
    components in this range will overlap.)
*)
(*        Dialect-specific script errors*:

    The range -2780 thru -2799 is reserved for dialect specific error codes for
    scripting components that support dialects. (Note that error codes from
    different scripting components in this range will overlap, as well as error
    codes from different dialects in the same scripting component.)
*)
(**************************************************************************
    OSA Interface Descriptions
**************************************************************************
    The OSA Interface is broken down into a required interface, and several
    optional interfaces to support additional functionality.  A given scripting
    component may choose to support only some of the optional interfaces in
    addition to the basic interface.  The OSA Components.Component Flags may be used to
    query the Components.Component Manager to find a scripting component with a particular
    capability, or determine if a particular scripting component supports a
    particular capability.
**************************************************************************)
(* OSA Components.Component Flags*: *)
    kOSASupportsCompiling*        = $0002;
    kOSASupportsGetSource*        = $0004;
    kOSASupportsAECoercion*        = $0008;
    kOSASupportsAESending*        = $0010;
    kOSASupportsRecording*        = $0020;
    kOSASupportsConvenience*        = $0040;
    kOSASupportsDialects*        = $0080;
    kOSASupportsEventHandling*    = $0100;

(* Components.Component Selectors*: *)
    kOSASelectLoad*                = $0001;
    kOSASelectStore*                = $0002;
    kOSASelectExecute*            = $0003;
    kOSASelectDisplay*            = $0004;
    kOSASelectScriptError*        = $0005;
    kOSASelectDispose*            = $0006;
    kOSASelectSetScriptInfo*        = $0007;
    kOSASelectGetScriptInfo*        = $0008;
    kOSASelectSetActiveProc*        = $0009;
    kOSASelectGetActiveProc*        = $000A;

(* Compiling*: *)
    kOSASelectScriptingComponentName* = $0102;
    kOSASelectCompile*            = $0103;
    kOSASelectCopyID*            = $0104;

(* GetSource*: *)
    kOSASelectGetSource*            = $0201;

(* AECoercion*: *)
    kOSASelectCoerceFromDesc*    = $0301;
    kOSASelectCoerceToDesc*        = $0302;

(* AESending*: *)
    kOSASelectSetSendProc*        = $0401;
    kOSASelectGetSendProc*        = $0402;
    kOSASelectSetCreateProc*        = $0403;
    kOSASelectGetCreateProc*        = $0404;
    kOSASelectSetDefaultTarget*    = $0405;

(* Recording*: *)
    kOSASelectStartRecording*    = $0501;
    kOSASelectStopRecording*        = $0502;

(* Convenience*: *)
    kOSASelectLoadExecute*        = $0601;
    kOSASelectCompileExecute*    = $0602;
    kOSASelectDoScript*            = $0603;

(* Dialects*: *)
    kOSASelectSetCurrentDialect*    = $0701;
    kOSASelectGetCurrentDialect*    = $0702;
    kOSASelectAvailableDialects*    = $0703;
    kOSASelectGetDialectInfo*    = $0704;
    kOSASelectAvailableDialectCodeList* = $0705;

(* Event Handling*: *)
    kOSASelectSetResumeDispatchProc* = $0801;
    kOSASelectGetResumeDispatchProc* = $0802;
    kOSASelectExecuteEvent*        = $0803;
    kOSASelectDoEvent*            = $0804;
    kOSASelectMakeContext*        = $0805;

(* scripting component specific selectors are added beginning with this value  *)
    kOSASelectComponentSpecificStart* = $1001;

(*        Mode Flags*:

    Warning*: These should not conflict with the AESend mode flags in
    AppleEvents.h, because we may want to use them as OSA mode flags too.
*)
(*
        This mode flag may be passed to OSALoad, OSAStore or OSACompile to
          instruct the scripting component to not retain the "source" of an
          expression.  This will cause the OSAGetSource call to return the error
          errOSASourceNotAvailable if used.  However, some scripting components
          may not retain the source anyway.  This is mainly used when either space
          efficiency is desired, or a script is to be "locked" so that its
          implementation may not be viewed.
    *)
    kOSAModePreventGetSource*    = $00000001;

(*
        These mode flags may be passed to OSACompile, OSAExecute, OSALoadExecute
          OSACompileExecute, OSADoScript, OSAExecuteEvent, or OSADoEvent to
          indicate whether or not the script may interact with the user, switch
          layer or reconnect if necessary.  Any AppleEvents will be sent with the
          corresponding AESend mode supplied.
    *)
    kOSAModeNeverInteract*        = AppleEvents.kAENeverInteract;
    kOSAModeCanInteract*            = AppleEvents.kAECanInteract;
    kOSAModeAlwaysInteract*        = AppleEvents.kAEAlwaysInteract;
    kOSAModeDontReconnect*        = AppleEvents.kAEDontReconnect;

(*
        This mode flag may be passed to OSACompile, OSAExecute, OSALoadExecute
          OSACompileExecute, OSADoScript, OSAExecuteEvent, or OSADoEvent to
          indicate whether or not AppleEvents should be sent with the
          kAECanSwitchLayer mode flag sent or not. NOTE*: This flag is exactly the
          opposite sense of the AppleEvents.AppleEvent flag kAECanSwitchLayer.  This is to
          provide a more convenient default, i.e. not supplying any mode
          (kOSAModeNull) means to send events with kAECanSwitchLayer.  Supplying
          the kOSAModeCantSwitchLayer mode flag will cause AESend to be called
          without kAECanSwitchLayer.
    *)
    kOSAModeCantSwitchLayer*        = $00000040;

(*
        This mode flag may be passed to OSACompile, OSAExecute, OSALoadExecute
          OSACompileExecute, OSADoScript, OSAExecuteEvent, or OSADoEvent to
          indicate whether or not AppleEvents should be sent with the kAEDontRecord
          mode flag sent or not. NOTE*: This flag is exactly the opposite sense of
          the AppleEvents.AppleEvent flag kAEDontRecord.  This is to provide a more convenient
          default, i.e. not supplying any mode (kOSAModeNull) means to send events
          with kAEDontRecord.  Supplying the kOSAModeDoRecord mode flag will
          cause AESend to be called without kAEDontRecord.
    *)
    kOSAModeDoRecord*            = $00001000;

(*
        This is a mode flag for OSACompile that indicates that a context should
          be created as the result of compilation. All handler definitions are
          inserted into the new context, and variables are initialized by
          evaluating their initial values in a null context (i.e. they must be
          constant expressions).
    *)
    kOSAModeCompileIntoContext*    = $00000002;

(*
        This is a mode flag for OSACompile that indicates that the previous
          script AIFF.ID (input to OSACompile) should be augmented with any new
          definitions in the sourceData rather than replaced with a new script.
          This means that the previous script AIFF.ID must designate a context.
          The presence of this flag causes the kOSAModeCompileIntoContext flag
          to be implicitly used, causing any new definitions to be initialized
          in a null context.
    *)
    kOSAModeAugmentContext*        = $00000004;

(*
        This mode flag may be passed to OSADisplay or OSADoScript to indicate
          that output only need be human-readable, not re-compilable by OSACompile.
          If used, output may be arbitrarily "beautified", e.g. quotes may be left
          off of string values, long lists may have elipses, etc.
    *)
    kOSAModeDisplayForHumans*    = $00000008;

(*
        This mode flag may be passed to OSAStore in the case where the scriptID
          is a context.  This causes the context to be saved, but not the context's
          parent context.  When the stored context is loaded back in, the parent
          will be kOSANullScript.
    *)
    kOSAModeDontStoreParent*        = $00010000;

(*
        This mode flag may be passed to OSAExecuteEvent to cause the event to
          be dispatched to the direct object of the event. The direct object (or
          subject attribute if the direct object is a non-object specifier) will
          be resolved, and the resulting script object will be the recipient of
          the message. The context argument to OSAExecuteEvent will serve as the
          root of the lookup/resolution process.
    *)
    kOSAModeDispatchToDirectObject* = $00020000;

(*
        This mode flag may be passed to OSAExecuteEvent to indicate that
          components do not have to get the data of object specifier arguments.
    *)
    kOSAModeDontGetDataForArguments* = $00040000;

(**************************************************************************
    OSA Basic Scripting Interface
**************************************************************************
    Scripting components must at least support the Basic Scripting interface.
**************************************************************************)
(*        Loading and Storing Scripts*:

    These routines allow scripts to be loaded and stored in their internal
    (possibly compiled, non-text) representation.
*)
(* Resource type for scripts *)
    kOSAScriptResourceType*        = kOSAGenericScriptingComponentSubtype;

(*
        Default type given to OSAStore which creates "generic" loadable script
          data descriptors.
    *)
    typeOSAGenericStorage*        = kOSAScriptResourceType;


PROCEDURE OSALoad*(scriptingComponent: Components.ComponentInstance; (*CONST*)VAR scriptData: AppleEvents.AEDesc; modeFlags: LONGINT; VAR resultingScriptID: OSAID): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $0001, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectLoad, 12);

        Errors*:
            badComponentInstance        invalid scripting component instance
            errOSASystemError
            errOSABadStorageType*:        scriptData not for this scripting component
            errOSACorruptData*:            data seems to be corrupt
            errOSADataFormatObsolete    script data format is no longer supported
            errOSADataFormatTooNew        script data format is from a newer version

        ModeFlags*:
            kOSAModePreventGetSource
    *)
PROCEDURE OSAStore*(scriptingComponent: Components.ComponentInstance; scriptID: OSAID; desiredType: AppleEvents.DescType; modeFlags: LONGINT; VAR resultingScriptData: AppleEvents.AEDesc): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $0002, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectStore, 16);

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
            errOSAInvalidID
            errOSABadStorageType*:    desiredType not for this scripting component

        ModeFlags*:
            kOSAModePreventGetSource
            kOSAModeDontStoreParent
    *)
(* Executing Scripts*: *)
PROCEDURE OSAExecute*(scriptingComponent: Components.ComponentInstance; compiledScriptID: OSAID; contextID: OSAID; modeFlags: LONGINT; VAR resultingScriptValueID: OSAID): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $0003, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectExecute, 16);
        This call runs a script.  The contextID represents the environment
        with which global variables in the script are resolved.  The constant
        kOSANullScript may be used for the contextID if the application wishes
        to not deal with context directly (a default one is associated with each
        scripting component instance).  The resultingScriptValueID is the
        result of evaluation, and contains a value which may be displayed using
        the OSAGetSource call.  The modeFlags convey scripting component
        specific information.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
            errOSAInvalidID
            errOSAScriptError*:        the executing script got an error

        ModeFlags*:
            kOSAModeNeverInteract
            kOSAModeCanInteract
            kOSAModeAlwaysInteract
            kOSAModeCantSwitchLayer
            kOSAModeDontReconnect
            kOSAModeDoRecord
    *)
(* Displaying results*: *)
PROCEDURE OSADisplay*(scriptingComponent: Components.ComponentInstance; scriptValueID: OSAID; desiredType: AppleEvents.DescType; modeFlags: LONGINT; VAR resultingText: AppleEvents.AEDesc): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $0004, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectDisplay, 16);
        This call is used to convert results (script value IDs) into displayable
        text. The desiredType should be at least typeChar, and modeFlags are
        scripting system specific flags to control the formatting of the
        resulting text. This call differs from OSAGetSource in that (1) it
        always produces at least typeChar, (2) is only works on script values,
        (3) it may display it's output in non-compilable form (e.g. without
        string quotes, elipses inserted in long and/or circular lists, etc.) and
        (4) it is required by the basic scripting interface.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
            errOSAInvalidID
            errAECoercionFail*:        desiredType not supported by scripting component

        ModeFlags*:
            kOSAModeDisplayForHumans
    *)
(* Getting Error Information*: *)
PROCEDURE OSAScriptError*(scriptingComponent: Components.ComponentInstance; selector: Types.OSType; desiredType: AppleEvents.DescType; VAR resultingErrorDescription: AppleEvents.AEDesc): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $0005, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectScriptError, 12);
        Whenever script execution returns errOSAExecutionError, this routine
        may be used to get information about that error.  The selector describes
        the type of information desired about the error (various selectors are
        listed below).  The desiredType indicates the data type of the result
        desired for that selector.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
            errOSABadSelector*:        selector not supported by scripting component
            errAECoercionFail*:        desiredType not supported by scripting component
    *)
(* OSAScriptError selectors*: *)
(*
        This selector is used to determine the error number of a script error.
        These error numbers may be either system error numbers, or error numbers
        that are scripting component specific.
        Required desiredTypes*:
              typeShortInteger
    *)

CONST
    kOSAErrorNumber*                = AppleEvents.keyErrorNumber;

(*
        This selector is used to determine the full error message associated
        with the error number.  It should include the name of the application
        which caused the error, as well as the specific error that occurred.
        This selector is sufficient for simple error reporting (but see
        kOSAErrorBriefMessage, below).
        Required desiredTypes*:
            typeChar                    error message string
    *)
    kOSAErrorMessage*            = AppleEvents.keyErrorString;

(*
        This selector is used to determine a brief error message associated with
        the error number.  This message and should not mention the name of the
        application which caused the error, any partial results or offending
        object (see kOSAErrorApp, kOSAErrorPartialResult and
        kOSAErrorOffendingObject, below).
        Required desiredTypes*:
              typeChar                    brief error message string
    *)
(*  0x65727262  *)
    kOSAErrorBriefMessage*        = LONG("errb");

(*
        This selector is used to determine which application actually got the
        error (if it was the result of an AESend), or the current application
        if ....
        Required desiredTypes*:
              typeProcessSerialNumber        PSN of the errant application
              typeChar                    name of the errant application
    *)
(*  0x65726170  *)
    kOSAErrorApp*                = LONG("erap");

(*
        This selector is used to determine any partial result returned by an
        operation. If an AESend call failed, but a partial result was returned,
        then the partial result may be returned as an AppleEvents.AEDesc.
        Required desiredTypes*:
              typeBest                    AppleEvents.AEDesc of any partial result
    *)
(*  0x70746c72   *)
    kOSAErrorPartialResult*        = LONG("ptlr");

(*
        This selector is used to determine any object which caused the error
        that may have been indicated by an application.  The result is an
        AppleEvents.AEDesc.
        Required desiredTypes*:
              typeBest                    AppleEvents.AEDesc of any offending object
    *)
(*  0x65726f62   *)
    kOSAErrorOffendingObject*    = LONG("erob");

(*
        This selector is used to determine the type expected by a coercion
        operation if a type error occurred.
    *)
(*  0x65727274   *)
    kOSAErrorExpectedType*        = LONG("errt");

(*
        This selector is used to determine the source text range (start and
        end positions) of where the error occurred.
        Required desiredTypes*:
              typeOSAErrorRange
    *)
(*  0x65726e67  *)
    kOSAErrorRange*                = LONG("erng");

(*
        An AppleEvents.AERecord type containing keyOSASourceStart and keyOSASourceEnd fields
        of type short.
    *)
(*  0x65726e67   *)
    typeOSAErrorRange*            = LONG("erng");

(* Field of a typeOSAErrorRange record of typeShortInteger *)
(*  0x73726373    *)
    keyOSASourceStart*            = LONG("srcs");

(* Field of a typeOSAErrorRange record of typeShortInteger *)
(*  0x73726365   *)
    keyOSASourceEnd*                = LONG("srce");

(* Disposing Script IDs*: *)

PROCEDURE OSADispose*(scriptingComponent: Components.ComponentInstance; scriptID: OSAID): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $0006, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectDispose, 4);
        Disposes a script or context.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
            errOSAInvalidID
    *)
(* Getting and Setting Script Information*: *)
PROCEDURE OSASetScriptInfo*(scriptingComponent: Components.ComponentInstance; scriptID: OSAID; selector: Types.OSType; value: LONGINT): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $0007, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectSetScriptInfo, 12);

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
            errOSAInvalidID
            errOSABadSelector*:        selector not supported by scripting component
                                    or selector not for this scriptID
    *)
PROCEDURE OSAGetScriptInfo*(scriptingComponent: Components.ComponentInstance; scriptID: OSAID; selector: Types.OSType; VAR result: LONGINT): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $0008, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectGetScriptInfo, 12);

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
            errOSAInvalidID
            errOSABadSelector*:        selector not supported by scripting component
                                    or selector not for this scriptID
    *)
(* Manipulating the ActiveProc*:

    Scripting systems will supply default values for these procedures if they
    are not set by the client*:
*)
TYPE
    OSAActiveProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (refCon: LONGINT): Types.OSErr;
    OSAActiveUPP* = Types.UniversalProcPtr;

CONST
    uppOSAActiveProcInfo* = $000000E0; (* PROCEDURE (4 byte param): 2 byte result; *)

PROCEDURE NewOSAActiveProc*(userRoutine: OSAActiveProcPtr): OSAActiveUPP;
    (*$IF NOT GENERATINGCFM *)
    INLINE PASCAL $2E9F;
    (*$END*)

PROCEDURE CallOSAActiveProc*(refCon: LONGINT; userRoutine: OSAActiveUPP): Types.OSErr;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $205F, $4E90;
    (*$END*)

PROCEDURE OSASetActiveProc*(scriptingComponent: Components.ComponentInstance; activeProc: OSAActiveUPP; refCon: LONGINT): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $0009, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectSetActiveProc, 8);
        If activeProc is nil, the default activeProc is used.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
    *)
PROCEDURE OSAGetActiveProc*(scriptingComponent: Components.ComponentInstance; VAR activeProc: OSAActiveUPP; VAR refCon: LONGINT): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $000A, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectGetActiveProc, 8);

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
    *)
(**************************************************************************
    OSA Optional Compiling Interface
**************************************************************************
    Scripting components that support the Compiling interface have the
    kOSASupportsCompiling bit set in it's Components.ComponentDescription.
**************************************************************************)
PROCEDURE OSAScriptingComponentName*(scriptingComponent: Components.ComponentInstance; VAR resultingScriptingComponentName: AppleEvents.AEDesc): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $0102, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectScriptingComponentName, 4);
        Given a scripting component, this routine returns the name of that
        scripting component in a type that is coercable to text (typeChar).
        The generic scripting component returns the name of the default
        scripting component.  This name should be sufficient to convey to the
        user the kind of script (syntax) he is expected to write.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
    *)
PROCEDURE OSACompile*(scriptingComponent: Components.ComponentInstance; (*CONST*)VAR sourceData: AppleEvents.AEDesc; modeFlags: LONGINT; VAR previousAndResultingScriptID: OSAID): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $0103, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectCompile, 12);
        Coerces input desc (possibly text) into a script's internal format.
        Once compiled, the script is ready to run.  The modeFlags convey
        scripting component specific information.  The previous script AIFF.ID
        (result parameter) is made to refer to the newly compiled script,
        unless it was originally kOSANullScript.  In this case a new script
        AIFF.ID is created and used.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
            errAECoercionFail*:        sourceData is not compilable
            errOSAScriptError*:        sourceData was a bad script (syntax error)
            errOSAInvalidID*:        previousAndResultingCompiledScriptID was not
                                    valid on input

        ModeFlags*:
            kOSAModePreventGetSource
            kOSAModeCompileIntoContext
            kOSAModeAugmentContext
            kOSAModeNeverInteract
            kOSAModeCanInteract
            kOSAModeAlwaysInteract
            kOSAModeCantSwitchLayer
            kOSAModeDontReconnect
            kOSAModeDoRecord
    *)
PROCEDURE OSACopyID*(scriptingComponent: Components.ComponentInstance; fromID: OSAID; VAR toID: OSAID): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $0104, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectCopyID, 8);
        If toID is a reference to kOSANullScript then it is updated to have a
        new scriptID value.  This call can be used to perform undo or revert
        operations on scripts.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
            errOSAInvalidID
    *)
(**************************************************************************
    OSA Optional GetSource Interface
**************************************************************************
    Scripting components that support the GetSource interface have the
    kOSASupportsGetSource bit set in it's Components.ComponentDescription.
**************************************************************************)
PROCEDURE OSAGetSource*(scriptingComponent: Components.ComponentInstance; scriptID: OSAID; desiredType: AppleEvents.DescType; VAR resultingSourceData: AppleEvents.AEDesc): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $0201, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectGetSource, 12);
        This routine causes a compiled script to be output in a form (possibly
        text) such that it is suitable to be passed back to OSACompile.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
            errOSAInvalidID
            errOSASourceNotAvailable    can't get source for this scriptID
    *)
(**************************************************************************
    OSA Optional AECoercion Interface
**************************************************************************
    Scripting components that support the AECoercion interface have the
    kOSASupportsAECoercion bit set in it's Components.ComponentDescription.
**************************************************************************)
PROCEDURE OSACoerceFromDesc*(scriptingComponent: Components.ComponentInstance; (*CONST*)VAR scriptData: AppleEvents.AEDesc; modeFlags: LONGINT; VAR resultingScriptID: OSAID): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $0301, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectCoerceFromDesc, 12);
        This routine causes script data to be coerced into a script value.
        If the scriptData is an AppleEvents.AppleEvent, then the resultingScriptID is a
        compiled script AIFF.ID (mode flags for OSACompile may be used in this case).
        Other scriptData descriptors create script value IDs.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError

        ModeFlags*:
            kOSAModePreventGetSource
            kOSAModeCompileIntoContext
            kOSAModeNeverInteract
            kOSAModeCanInteract
            kOSAModeAlwaysInteract
            kOSAModeCantSwitchLayer
            kOSAModeDontReconnect
            kOSAModeDoRecord
    *)
PROCEDURE OSACoerceToDesc*(scriptingComponent: Components.ComponentInstance; scriptID: OSAID; desiredType: AppleEvents.DescType; modeFlags: LONGINT; VAR result: AppleEvents.AEDesc): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $0302, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectCoerceToDesc, 16);
        This routine causes a script value to be coerced into any desired form.
        If the scriptID denotes a compiled script, then it may be coerced to
        typeAppleEvent.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
            errOSAInvalidID
    *)
(**************************************************************************
    OSA Optional AESending Interface
**************************************************************************
    Scripting components that support the AESending interface have the
    kOSASupportsAESending bit set in it's Components.ComponentDescription.
**************************************************************************)
(*
    Scripting systems will supply default values for these procedures if they
    are not set by the client*:
*)
PROCEDURE OSASetSendProc*(scriptingComponent: Components.ComponentInstance; sendProc: OSASendUPP; refCon: LONGINT): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $0401, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectSetSendProc, 8);
        If sendProc is nil, the default sendProc is used.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
    *)
PROCEDURE OSAGetSendProc*(scriptingComponent: Components.ComponentInstance; VAR sendProc: OSASendUPP; VAR refCon: LONGINT): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $0402, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectGetSendProc, 8);

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
    *)
PROCEDURE OSASetCreateProc*(scriptingComponent: Components.ComponentInstance; createProc: OSACreateAppleEventUPP; refCon: LONGINT): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $0403, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectSetCreateProc, 8);
        If createProc is nil, the default createProc is used.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
    *)
PROCEDURE OSAGetCreateProc*(scriptingComponent: Components.ComponentInstance; VAR createProc: OSACreateAppleEventUPP; VAR refCon: LONGINT): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $0404, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectGetCreateProc, 8);

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
    *)
PROCEDURE OSASetDefaultTarget*(scriptingComponent: Components.ComponentInstance; (*CONST*)VAR target: AppleEvents.AEAddressDesc): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $0405, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectSetDefaultTarget, 4);
        This routine sets the default target application for AE sending.
        It also establishes the default target from which terminologies come.
        It is effectively like having an AppleScript "tell" statement around
        the entire program.  If this routine is not called, or if the target
        is a null AppleEvents.AEDesc, then the current application is the default target.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
    *)
(**************************************************************************
    OSA Optional Recording Interface
**************************************************************************
    Scripting components that support the Recording interface have the
    kOSASupportsRecording bit set in it's Components.ComponentDescription.
**************************************************************************)
PROCEDURE OSAStartRecording*(scriptingComponent: Components.ComponentInstance; VAR compiledScriptToModifyID: OSAID): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $0501, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectStartRecording, 4);
        Starts recording.  If compiledScriptToModifyID is kOSANullScript, a
        new script AIFF.ID is created and returned.  If the current application has
        a handler for the kOSARecordedText event, then kOSARecordedText events
        are sent to the application containing the text of each AppleEvents.AppleEvent
        recorded.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
            errOSAInvalidID
            errOSARecordingIsAlreadyOn
    *)
PROCEDURE OSAStopRecording*(scriptingComponent: Components.ComponentInstance; compiledScriptID: OSAID): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $0502, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectStopRecording, 4);
        If compiledScriptID is not being recorded into or recording is not
        currently on, no error is returned.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
            errOSAInvalidID
    *)
(**************************************************************************
    OSA Optional Convenience Interface
**************************************************************************
    Scripting components that support the Convenience interface have the
    kOSASupportsConvenience bit set in it's Components.ComponentDescription.
**************************************************************************)
PROCEDURE OSALoadExecute*(scriptingComponent: Components.ComponentInstance; (*CONST*)VAR scriptData: AppleEvents.AEDesc; contextID: OSAID; modeFlags: LONGINT; VAR resultingScriptValueID: OSAID): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $0601, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectLoadExecute, 16);
        This routine is effectively equivalent to calling OSALoad followed by
        OSAExecute.  After execution, the compiled source is disposed.  Only the
        resulting value AIFF.ID is retained.

        Errors*:
            badComponentInstance        invalid scripting component instance
            errOSASystemError
            errOSABadStorageType*:        scriptData not for this scripting component
            errOSACorruptData*:            data seems to be corrupt
            errOSADataFormatObsolete    script data format is no longer supported
            errOSADataFormatTooNew        script data format is from a newer version
            errOSAInvalidID
            errOSAScriptError*:            the executing script got an error

        ModeFlags*:
            kOSAModeNeverInteract
            kOSAModeCanInteract
            kOSAModeAlwaysInteract
            kOSAModeCantSwitchLayer
            kOSAModeDontReconnect
            kOSAModeDoRecord
    *)
PROCEDURE OSACompileExecute*(scriptingComponent: Components.ComponentInstance; (*CONST*)VAR sourceData: AppleEvents.AEDesc; contextID: OSAID; modeFlags: LONGINT; VAR resultingScriptValueID: OSAID): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $0602, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectCompileExecute, 16);
        This routine is effectively equivalent to calling OSACompile followed by
        OSAExecute.  After execution, the compiled source is disposed.  Only the
        resulting value AIFF.ID is retained.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
            errAECoercionFail*:        sourceData is not compilable
            errOSAScriptError*:        sourceData was a bad script (syntax error)
            errOSAInvalidID*:        previousAndResultingCompiledScriptID was not
                                    valid on input
            errOSAScriptError*:        the executing script got an error

        ModeFlags*:
            kOSAModeNeverInteract
            kOSAModeCanInteract
            kOSAModeAlwaysInteract
            kOSAModeCantSwitchLayer
            kOSAModeDontReconnect
            kOSAModeDoRecord
    *)
PROCEDURE OSADoScript*(scriptingComponent: Components.ComponentInstance; (*CONST*)VAR sourceData: AppleEvents.AEDesc; contextID: OSAID; desiredType: AppleEvents.DescType; modeFlags: LONGINT; VAR resultingText: AppleEvents.AEDesc): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $14, $0603, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectDoScript, 20);
        This routine is effectively equivalent to calling OSACompile followed by
        OSAExecute and then OSADisplay.  After execution, the compiled source
        and the resulting value are is disposed.  Only the resultingText
        descriptor is retained.  If a script error occur during processing, the
        resultingText gets the error message of the error, and errOSAScriptError
        is returned.  OSAScriptError may still be used to extract more
        information about the particular error.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
            errAECoercionFail*:        sourceData is not compilable or
                                    desiredType not supported by scripting component
            errOSAScriptError*:        sourceData was a bad script (syntax error)
            errOSAInvalidID*:        previousAndResultingCompiledScriptID was not
                                    valid on input
            errOSAScriptError*:        the executing script got an error

        ModeFlags*:
            kOSAModeNeverInteract
            kOSAModeCanInteract
            kOSAModeAlwaysInteract
            kOSAModeCantSwitchLayer
            kOSAModeDontReconnect
            kOSAModeDoRecord
            kOSAModeDisplayForHumans
    *)
(**************************************************************************
    OSA Optional Dialects Interface
**************************************************************************
    Scripting components that support the Dialects interface have the
    kOSASupportsDialects bit set in it's Components.ComponentDescription.
**************************************************************************)
(*
    These calls allows an scripting component that supports different dialects
    to dynamically switch between those dialects.  Although this interface is
    specified, the particular dialect codes are scripting component dependent.
*)
PROCEDURE OSASetCurrentDialect*(scriptingComponent: Components.ComponentInstance; dialectCode: INTEGER): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $2, $0701, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectSetCurrentDialect, 2);

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
            errOSANoSuchDialect*:    invalid dialectCode
    *)
PROCEDURE OSAGetCurrentDialect*(scriptingComponent: Components.ComponentInstance; VAR resultingDialectCode: INTEGER): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $0702, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectGetCurrentDialect, 4);

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
    *)
PROCEDURE OSAAvailableDialects*(scriptingComponent: Components.ComponentInstance; VAR resultingDialectInfoList: AppleEvents.AEDesc): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $0703, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectAvailableDialects, 4);
        This call return an AEList containing information about each of the
        currently available dialects of a scripting component.  Each item
        is an AppleEvents.AERecord of typeOSADialectInfo that contains at least the fields
        keyOSADialectName, keyOSADialectCode, KeyOSADialectLangCode and
        keyOSADialectScriptCode.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
    *)
PROCEDURE OSAGetDialectInfo*(scriptingComponent: Components.ComponentInstance; dialectCode: INTEGER; selector: Types.OSType; VAR resultingDialectInfo: AppleEvents.AEDesc): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $A, $0704, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectGetDialectInfo, 10);
        This call gives information about the specified dialect of a scripting
        component. It returns an AppleEvents.AEDesc whose type depends on the selector
        specified. Available selectors are the same as the field keys for a
        dialect info record. The type of AppleEvents.AEDesc returned is the same as the
        type of the field that has same key as the selector.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
             errOSABadSelector
            errOSANoSuchDialect*:    invalid dialectCode
    *)
PROCEDURE OSAAvailableDialectCodeList*(scriptingComponent: Components.ComponentInstance; VAR resultingDialectCodeList: AppleEvents.AEDesc): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $4, $0705, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectAvailableDialectCodeList, 4);
        This is alternative to OSAGetAvailableDialectCodeList. Use this call
        and  OSAGetDialectInfo to get information on dialects.
        This call return an AEList containing dialect code for each of the
        currently available dialects of a scripting component. Each dialect
        code is a short integer of type typeShortInteger.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError

        Type of a dialect info record containing at least keyOSADialectName
        and keyOSADialectCode fields.

        keys for dialect info record, also used as selectors to OSAGetDialectInfo.

        Field of a typeOSADialectInfo record of typeChar.
        Field of a typeOSADialectInfo record of typeShortInteger.
        Field of a typeOSADialectInfo record of typeShortInteger.
        Field of a typeOSADialectInfo record of typeShortInteger.
    *)
(**************************************************************************
    OSA Optional Event Handling Interface
**************************************************************************
    Scripting components that support the Event Handling interface have the
    kOSASupportsEventHandling bit set in it's Components.ComponentDescription.
**************************************************************************)
PROCEDURE OSASetResumeDispatchProc*(scriptingComponent: Components.ComponentInstance; resumeDispatchProc: AppleEvents.AEEventHandlerUPP; refCon: LONGINT): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $0801, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectSetResumeDispatchProc, 8);
        This function is used to set the ResumeDispatchProc that will be used
        by OSAExecuteEvent and OSADoEvent if either no event handler can be
        found in the context, or the context event hander "continues" control
        onward. The two constants kOSAUseStandardDispatch and kOSANoDispatch
        may also be passed to this routine indicating that the handler registered
        in the application with AEInstallEventHandler should be used, or no
        dispatch should occur, respectively.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
    *)

CONST
    kOSAUseStandardDispatch*        = AppleEvents.kAEUseStandardDispatch;

(*
        Special ResumeDispatchProc constant which may be passed to
        OSASetResumeDispatchProc indicating that the handler registered
        in the application with AEInstallEventHandler should be used.

        NOTE*:    Had to remove the cast (AEEventHandlerUPP).  The C compiler
                doesn't allow pointer types to be assigned to an enum.  All
                constants must be assigned as enums to translate properly to
                Pascal.
    *)
    kOSANoDispatch*                = AppleEvents.kAENoDispatch;

(*
        Special ResumeDispatchProc constant which may be passed to
        OSASetResumeDispatchProc indicating that no dispatch should occur.

        NOTE*:    Had to remove the cast (AEEventHandlerUPP).  The C compiler
                doesn't allow pointer types to be assigned to an enum.  All
                constants must be assigned as enums to translate properly to
                Pascal.
    *)
    kOSADontUsePhac*                = $0001;

(*
        Special refCon constant that may be given to OSASetResumeDispatchProc
        only when kOSAUseStandardDispatch is used as the ResumeDispatchProc.
        This causes the standard dispatch to be performed, except the phac
        handler is not called.  This is useful during tinkerability, when
        the phac handler is used to lookup a context associated with an event's
        direct parameter, and call OSAExecuteEvent or OSADoEvent.  Failure to
        bypass the phac handler would result in an infinite loop.
    *)

PROCEDURE OSAGetResumeDispatchProc*(scriptingComponent: Components.ComponentInstance; VAR resumeDispatchProc: AppleEvents.AEEventHandlerUPP; VAR refCon: LONGINT): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $8, $0802, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectGetResumeDispatchProc, 8);
        Returns the registered ResumeDispatchProc.  If no ResumeDispatchProc has
        been registered, then kOSAUseStandardDispatch (the default) is returned.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
    *)
PROCEDURE OSAExecuteEvent*(scriptingComponent: Components.ComponentInstance; (*CONST*)VAR theAppleEvent: AppleEvents.AppleEvent; contextID: OSAID; modeFlags: LONGINT; VAR resultingScriptValueID: OSAID): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $0803, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectExecuteEvent, 16);
        This call is similar to OSAExecute except the initial command to
        execute comes in the form of an AppleEvents.AppleEvent.  If the contextID
        defines any event handlers for that event, they are used to process
        the event.  If no event handler can be found in the context
        errAEEventNotHandled is returned.  If an event handler is found and
        the hander "continues" control onward, the ResumeDispatchProc
        (registered with OSASetResumeDispatchProc, above) is called given the
        AppleEvents.AppleEvent.  The result is returned as a scriptValueID.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
            errOSAInvalidID
            errOSAScriptError*:        the executing script got an error
            errAEEventNotHandled*:    no handler for event in contextID

        ModeFlags*:
            kOSAModeNeverInteract
            kOSAModeCanInteract
            kOSAModeAlwaysInteract
            kOSAModeCantSwitchLayer
            kOSAModeDontReconnect
            kOSAModeDoRecord
    *)
PROCEDURE OSADoEvent*(scriptingComponent: Components.ComponentInstance; (*CONST*)VAR theAppleEvent: AppleEvents.AppleEvent; contextID: OSAID; modeFlags: LONGINT; VAR reply: AppleEvents.AppleEvent): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $10, $0804, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectDoEvent, 16);
        This call is similar to OSADoScript except the initial command to
        execute comes in the form of an AppleEvents.AppleEvent, and the result is an
        AppleEvents.AppleEvent reply record.  If the contextID defines any event handlers
        for that event, they are used to process the event.  If no event handler
        can be found in the context errAEEventNotHandled is returned.  If an
        event handler is found and the hander "continues" control onward, the
        ResumeDispatchProc (registered with OSASetResumeDispatchProc, above) is
        called given the AppleEvents.AppleEvent.  The result is returned in the form of an
        AppleEvents.AppleEvent reply descriptor. If at any time the script gets an error, or
        if the ResumeDispatchProc returns a reply event indicating an error,
        then the OSADoEvent call itself returns an error reply (i.e. OSADoEvent
        should never return errOSAScriptError).  Any error result returned by
        the ResumeDispatchProc will be returned by OSADoEvent.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
            errOSAInvalidID
            errAEEventNotHandled*:    no handler for event in contextID

        ModeFlags*:
            kOSAModeNeverInteract
            kOSAModeCanInteract
            kOSAModeAlwaysInteract
            kOSAModeCantSwitchLayer
            kOSAModeDontReconnect
            kOSAModeDoRecord
    *)
PROCEDURE OSAMakeContext*(scriptingComponent: Components.ComponentInstance; (*CONST*)VAR contextName: AppleEvents.AEDesc; parentContext: OSAID; VAR resultingContextID: OSAID): OSAError;
    (*$IF NOT GENERATINGCFM*)
    INLINE PASCAL $2F3C, $C, $0805, $7000, $A82A;
    (*$END*)
(*
        OSAComponentFunctionInline(kOSASelectMakeContext, 12);
        Makes a new empty context which may be passed to OSAExecute or
        OSAExecuteEvent.  If contextName is typeNull, an unnamed context is
        created. If parentContext is kOSANullScript then the resulting context
        does not inherit bindings from any other context.

        Errors*:
            badComponentInstance    invalid scripting component instance
            errOSASystemError
            errOSAInvalidID
            errAECoercionFail*:        contextName is invalid
    *)

(* $ALIGN RESET*)
(* $POP*)

 END OSA.